{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--BOOK_INFORMATION-->\n",
    "<img align=\"left\" style=\"padding-right:10px;\" src=\"figures/PDSH-cover-small.png\">\n",
    "*This notebook contains an excerpt from the [Python Data Science Handbook](http://shop.oreilly.com/product/0636920034919.do) by Jake VanderPlas; the content is available [on GitHub](https://github.com/jakevdp/PythonDataScienceHandbook).*\n",
    "\n",
    "*The text is released under the [CC-BY-NC-ND license](https://creativecommons.org/licenses/by-nc-nd/3.0/us/legalcode), and code is released under the [MIT license](https://opensource.org/licenses/MIT). If you find this content useful, please consider supporting the work by [buying the book](http://shop.oreilly.com/product/0636920034919.do)!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Introducing Scikit-Learn](05.02-Introducing-Scikit-Learn.ipynb) | [Contents](Index.ipynb) | [Feature Engineering](05.04-Feature-Engineering.ipynb) >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 超参数和模型验证"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "在上一节中，我们看到了应用监督机器学习模型的基本方法：\n",
    "1. 选择模型分类\n",
    "2. 选择模型超参数\n",
    "3. 用模拟数据拟合模型\n",
    "4. 用模型来预测新数据的标签\n",
    "\n",
    "\n",
    "前两部分—模型的选择和超参数的选择—可能是有效使用这些机器学习工具和技术的最重要的部分。\n",
    "为了做出正确的选择，我们需要一种方法来验证我们的模型和超参数是否可以很好的拟合数据。\n",
    "虽然这听起来很简单，但要想顺利完成也必须避过一些坑"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 什么是模型验证\n",
    "\n",
    "In principle, model validation is very simple: after choosing a model and its hyperparameters, we can estimate how effective it is by applying it to some of the training data and comparing the prediction to the known value.\n",
    "\n",
    "模型验证其实非常简单：在选择模型及其超参数之后，我们可以通过将模型应用到一些训练数据并将预测与已知值进行比较来估计它的有效性。\n",
    "\n",
    "The following sections first show a naive approach to model validation and why it\n",
    "fails, before exploring the use of holdout sets and cross-validation for more robust\n",
    "model evaluation.\n",
    "\n",
    "下面的部分首先展示了一种简单的模型验证方法，以及为什么它失败，在探索使用留出集（holdout sets）和交叉验证（cross-validation）以实现更可靠的模型验证。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model validation the wrong way 错误的模型验证方法\n",
    "\n",
    "Let's demonstrate the naive approach to validation using the Iris data, which we saw in the previous section.\n",
    "We will start by loading the data:\n",
    "\n",
    "让我们用前面用过的 Iris 数据来演示一个简单的模型验证方法，我们将从加载数据开始："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "iris = load_iris()\n",
    "X = iris.data\n",
    "y = iris.target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we choose a model and hyperparameters. Here we'll use a *k*-neighbors classifier with ``n_neighbors=1``.\n",
    "This is a very simple and intuitive model that says \"the label of an unknown point is the same as the label of its closest training point:\"\n",
    "\n",
    "接下来，我们选择一个模型和超参数。在这里我们将使用“n_neighbors=1”的 k-neighbors 分类器。\n",
    "这是一个非常简单和直观的模型， “未知点的标签和它最接近的训练点的标签是一样的：”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "model = KNeighborsClassifier(n_neighbors=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we train the model, and use it to predict labels for data we already know:\n",
    "\n",
    "然后我们训练模型，用它来预测我们已经知道的数据的标签："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(X, y)\n",
    "y_model = model.predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we compute the fraction of correctly labeled points:\n",
    "\n",
    "最后，计算模型的准确率："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "accuracy_score(y, y_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see an accuracy score of 1.0, which indicates that 100% of points were correctly labeled by our model!\n",
    "But is this truly measuring the expected accuracy? Have we really come upon a model that we expect to be correct 100% of the time?\n",
    "\n",
    "我们看到准确率是1.0，这表明100%的点被我们的模型正确地标记了！这样测量的准确率可靠吗？我们真的有了一个任何时候都能百分百正确的模型吗？\n",
    "\n",
    "As you may have gathered, the answer is no.\n",
    "In fact, this approach contains a fundamental flaw: *it trains and evaluates the model on the same data*.\n",
    "Furthermore, the nearest neighbor model is an *instance-based* estimator that simply stores the training data, and predicts labels by comparing new data to these stored points: except in contrived cases, it will get 100% accuracy *every time!*\n",
    "\n",
    "事实上，这种方法包含一个基本的缺陷：它在相同的数据上对模型进行了训练和评估。此外，k-neighbors 是一种与距离相关的评估器，它简单地存储训练数据，并通过将新数据与这些存储点进行比较来预测标签：除了在人为的情况下，它每次都会得到百分之百的准确性！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model validation the right way: Holdout sets 模型验证正确方法：留出集\n",
    "\n",
    "So what can be done?\n",
    "A better sense of a model's performance can be found using what's known as a *holdout set*: that is, we hold back some subset of the data from the training of the model, and then use this holdout set to check the model performance.\n",
    "This splitting can be done using the ``train_test_split`` utility in Scikit-Learn:\n",
    "\n",
    "那么，我们能做些什么呢？可以通过所谓的“holdout set”来找到更好的模型性能：也就是说，我们从模型的培训中保留了一些数据的子集，然后使用这部分预留的数据集合来检查模型的性能。这种分离可以通过Scikit-Learn中的train_test_split实用工具来完成："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9066666666666666"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.cross_validation import train_test_split\n",
    "# split the data with 50% in each set\n",
    "X1, X2, y1, y2 = train_test_split(X, y, random_state=0,\n",
    "                                  train_size=0.5)\n",
    "\n",
    "# fit the model on one set of data\n",
    "model.fit(X1, y1)\n",
    "\n",
    "# evaluate the model on the second set of data\n",
    "y2_model = model.predict(X2)\n",
    "accuracy_score(y2, y2_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see here a more reasonable result: the nearest-neighbor classifier is about 90% accurate on this hold-out set.\n",
    "The hold-out set is similar to unknown data, because the model has not \"seen\" it before.\n",
    "\n",
    "我们在这里看到了一个更合理的结果：在这个 hold-out 的集合中，邻近的分类器大约有90%的准确率。这个 hold-out 的集合类似于未知的数据，因为这个模型以前没有“看到”它。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model validation via cross-validation  交叉验证\n",
    "\n",
    "One disadvantage of using a holdout set for model validation is that we have lost a portion of our data to the model training.\n",
    "In the above case, half the dataset does not contribute to the training of the model!\n",
    "This is not optimal, and can cause problems – especially if the initial set of training data is small.\n",
    "\n",
    "在使用 holdout 模型验证有一个缺点，就是一部分数据没有参与到模型训练当中。在上面的例子中，一半的数据集对模型的训练没有贡献！\n",
    "这当然不是最优的，并且会导致问题——特别是训练数据集是很小的时候。\n",
    "\n",
    "One way to address this is to use *cross-validation*; that is, to do a sequence of fits where each subset of the data is used both as a training set and as a validation set.\n",
    "Visually, it might look something like this:\n",
    "\n",
    "解决这个问题的方法是使用交叉验证;也就是说，要做一系列的调整，其中的每个子集都被用作训练集和验证集，从图形上看，它可能是这样的：\n",
    "\n",
    "![](figures/05.03-2-fold-CV.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#2-Fold-Cross-Validation)\n",
    "\n",
    "Here we do two validation trials, alternately using each half of the data as a holdout set.\n",
    "Using the split data from before, we could implement it like this:\n",
    "\n",
    "在这里，我们做两个验证试验，交替使用每一半的数据作为 留出集。使用以前的分割数据，我们可以像这样实现它："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.96, 0.9066666666666666)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y2_model = model.fit(X1, y1).predict(X2)\n",
    "y1_model = model.fit(X2, y2).predict(X1)\n",
    "accuracy_score(y1, y1_model), accuracy_score(y2, y2_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What comes out are two accuracy scores, which we could combine (by, say, taking the mean) to get a better measure of the global model performance.\n",
    "This particular form of cross-validation is a *two-fold cross-validation*—that is, one in which we have split the data into two sets and used each in turn as a validation set.\n",
    "\n",
    "结果是两个准确率，我们可以结合（比如说，取均值）来更好地衡量整个模型的性能。这种交叉验证的特殊形式是`双重交叉验证`——也就是说，我们将数据分割成两组，并依次作为验证集使用。\n",
    "\n",
    "We could expand on this idea to use even more trials, and more folds in the data—for example, here is a visual depiction of five-fold cross-validation:\n",
    "\n",
    "我们可以扩展这个想法，在数据中实现多轮的交叉验证——例如，这里有一个五轮交叉验证的图形描述：\n",
    "\n",
    "![](figures/05.03-5-fold-CV.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#5-Fold-Cross-Validation)\n",
    "\n",
    "Here we split the data into five groups, and use each of them in turn to evaluate the model fit on the other 4/5 of the data.\n",
    "This would be rather tedious to do by hand, and so we can use Scikit-Learn's ``cross_val_score`` convenience routine to do it succinctly:\n",
    "\n",
    "在这里，我们将数据分成5组，然后依次使用它们来评估模型是否适合其他4/5的数据。\n",
    "这将是一件相当乏味的事情，所以我们可以使用Scikit-Learn的“cross_val_score”便利程序来简洁地完成："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.96666667, 0.96666667, 0.93333333, 0.93333333, 1.        ])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.cross_validation import cross_val_score\n",
    "cross_val_score(model, X, y, cv=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeating the validation across different subsets of the data gives us an even better idea of the performance of the algorithm.\n",
    "\n",
    "在数据的不同子集上重复验证，使我们对算法的性能有了更好的了解。\n",
    "\n",
    "Scikit-Learn implements a number of useful cross-validation schemes that are useful in particular situations; these are implemented via iterators in the ``cross_validation`` module.\n",
    "\n",
    "Scikit-Learn实现了许多有用的交叉验证方案，这些方案在特定情况下是有用的;这些是通过 ``cross_validation`` 模块中的迭代器实现的。\n",
    "\n",
    "For example, we might wish to go to the extreme case in which our number of folds is equal to the number of data points: that is, we train on all points but one in each trial.\n",
    "This type of cross-validation is known as *leave-one-out* cross validation, and can be used as follows:\n",
    "\n",
    "例如，我们可能希望进入一个极端的情况，在这个例子中，我们的折叠数等于数据点的数量：也就是说，我们在所有的点上进行训练，但是在每次都只用其中一个点验证。\n",
    "这种类型的交叉验证被称为 LOO （ leave-one-out 只留一个）交叉验证，可以使用如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 0., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 1., 1.,\n",
       "       1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.cross_validation import LeaveOneOut\n",
    "scores = cross_val_score(model, X, y, cv=LeaveOneOut(len(X)))\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we have 150 samples, the leave one out cross-validation yields scores for 150 trials, and the score indicates either successful (1.0) or unsuccessful (0.0) prediction.\n",
    "Taking the mean of these gives an estimate of the error rate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.95999999999999996"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other cross-validation schemes can be used similarly.\n",
    "For a description of what is available in Scikit-Learn, use IPython to explore the ``sklearn.cross_validation`` submodule, or take a look at Scikit-Learn's online [cross-validation documentation](http://scikit-learn.org/stable/modules/cross_validation.html).\n",
    "\n",
    "\n",
    "其他交叉验证方案也可以类似地使用方法。想了解更多 Scikit-Learn 的内容，请使用IPython来探索 ``sklearn.cross_validation`` 交叉验证子模块，或者看一下Scikit-Learn 交叉验证的在线文档。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selecting the Best Model 选择最好的模型\n",
    "\n",
    "Now that we've seen the basics of validation and cross-validation, we will go into a litte more depth regarding model selection and selection of hyperparameters.\n",
    "\n",
    " 我们已经了解了验证和交叉验证的基础知识，我们将更深入地讨论模型选择和超参数的选择。\n",
    "\n",
    "These issues are some of the most important aspects of the practice of machine learning, and I find that this information is often glossed over in introductory machine learning tutorials.\n",
    "\n",
    "这些问题是机器学习实践中最重要的一些方面，我发现这些信息在入门的机器学习教程中经常被掩盖。\n",
    "\n",
    "Of core importance is the following question: *if our estimator is underperforming, how should we move forward?*\n",
    "There are several possible answers:\n",
    "\n",
    "最重要的是以下问题：如果我们的评估器表现不佳，我们应该如何前进？有几个可能的答案：\n",
    "\n",
    "- Use a more complicated/more flexible model  使用更复杂/更灵活的模型\n",
    "- Use a less complicated/less flexible model  使用一个不太复杂/不太灵活的模型\n",
    "- Gather more training samples           收集更多的训练样本\n",
    "- Gather more data to add features to each sample  集更多的数据，为每个样本添加更多的特征\n",
    "\n",
    "The answer to this question is often counter-intuitive.\n",
    "In particular, sometimes using a more complicated model will give worse results, and adding more training samples may not improve your results!\n",
    "The ability to determine what steps will improve your model is what separates the successful machine learning practitioners from the unsuccessful.\n",
    "\n",
    "这个问题的答案往往是反直觉的。特别是，有时使用更复杂的模型会带来更糟糕的结果，增加更多的训练样本可能不会改善你的结果！改善模型性能能力的高低，是机器学习实践者是否成功的标志。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Bias-variance trade-off  偏差和方差权衡\n",
    "\n",
    "Fundamentally, the question of \"the best model\" is about finding a sweet spot in the tradeoff between *bias* and *variance*.\n",
    "Consider the following figure, which presents two regression fits to the same dataset:\n",
    "\n",
    "从根本上说，“最佳模型”的问题在于如何在偏差和方差之间找到一个平衡点。如图所示，它给出了拟合同一个数据集的两个不同的回归模型：\n",
    "\n",
    "![](figures/05.03-bias-variance.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#Bias-Variance-Tradeoff)\n",
    "\n",
    "It is clear that neither of these models is a particularly good fit to the data, but they fail in different ways.\n",
    "\n",
    "很明显，这两种模型拟合的都不是特别好，但它们的问题却不一样。\n",
    "\n",
    "The model on the left attempts to find a straight-line fit through the data.\n",
    "Because the data are intrinsically more complicated than a straight line, the straight-line model will never be able to describe this dataset well.\n",
    "\n",
    "左边的模型试图通过数据找到一条直线。因为数据本质上比直线更复杂，所以直线模型永远不能很好地描述这个数据集。\n",
    "\n",
    "Such a model is said to *underfit* the data: that is, it does not have enough model flexibility to suitably account for all the features in the data; another way of saying this is that the model has high *bias*.\n",
    "\n",
    "这样的模型被认为是不符合数据的：也就是说，它没有足够的模型灵活性来适当地解释数据中的所有特性;另一种说法是模型有很高的``偏差``。\n",
    "\n",
    "The model on the right attempts to fit a high-order polynomial through the data.\n",
    "Here the model fit has enough flexibility to nearly perfectly account for the fine features in the data, but even though it very accurately describes the training data, its precise form seems to be more reflective of the particular noise properties of the data rather than the intrinsic properties of whatever process generated that data.\n",
    "Such a model is said to *overfit* the data: that is, it has so much model flexibility that the model ends up accounting for random errors as well as the underlying data distribution; another way of saying this is that the model has high *variance*.\n",
    "\n",
    "右边的模型试图通过数据来匹配高阶多项式。这里模型适合有足够的灵活性,几乎完全适应了所有的数据特征,但即使它非常准确地描述了训练数据,其精确的形式似乎更反映特定噪声数据而不是内在属性的属性的过程生成的数据。这样的模型被认为过于拟合数据：也就是说，它具有如此多的模型灵活性，以至于模型适应的所有数据特征的同时也适应了随机误差; 另一种说法就是模型具有``高方差``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To look at this in another light, consider what happens if we use these two models to predict the y-value for some new data.\n",
    "In the following diagrams, the red/lighter points indicate data that is omitted from the training set:\n",
    "\n",
    "从另一个角度来看，考虑一下如果我们使用这两个模型来预测一些新数据的y值，会发生什么。在下面的图中，浅红点表示训练集中遗漏的数据：\n",
    "\n",
    "![](figures/05.03-bias-variance-2.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#Bias-Variance-Tradeoff-Metrics)\n",
    "\n",
    "The score here is the $R^2$ score, or [coefficient of determination](https://en.wikipedia.org/wiki/Coefficient_of_determination), which measures how well a model performs relative to a simple mean of the target values. $R^2=1$ indicates a perfect match, $R^2=0$ indicates the model does no better than simply taking the mean of the data, and negative values mean even worse models.\n",
    "From the scores associated with these two models, we can make an observation that holds more generally:\n",
    "\n",
    "这里的得分是$R^2$ score，也就是确定系数，它衡量一个模型相对于目标值的简单平均值的表现。$R^2=1$表示一个完美的匹配， $R^2=0$表明模型并不比简单地取数据的平均值好，而负的值意味着更糟糕的模型。从与这两种模型相关的分数中，我们可以得出一个更普遍的观察结果：\n",
    "\n",
    "- For high-bias models, the performance of the model on the validation set is similar to the performance on the training set.\n",
    "对于高偏差模型，在验证集中的模型的性能与训练集的性能相似。\n",
    "- For high-variance models, the performance of the model on the validation set is far worse than the performance on the training set.\n",
    "对于高方差模型，在验证集中的模型的性能要比训练集的性能差得多。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we imagine that we have some ability to tune the model complexity, we would expect the training score and validation score to behave as illustrated in the following figure:\n",
    "\n",
    "假设我们有能力调整模型的复杂度，我们会期望训练分数和验证分数表现得如下图所示：\n",
    "\n",
    "![](figures/05.03-validation-curve.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#Validation-Curve)\n",
    "\n",
    "The diagram shown here is often called a *validation curve*, and we see the following essential features:\n",
    "这里所示的图表通常被称为``验证曲线``，我们可以看到以下基本特征：\n",
    "\n",
    "- The training score is everywhere higher than the validation score. This is generally the case: the model will be a better fit to data it has seen than to data it has not seen.  训练分数在任何地方都比验证分数高。这通常是这样的：模型将更适合于它所接触过的数据。\n",
    "- For very low model complexity (a high-bias model), the training data is under-fit, which means that the model is a poor predictor both for the training data and for any previously unseen data. 对于非常低的模型复杂度（高偏差模型），训练集数据是不合适的，这意味着模型对于训练数据和任何以前未接触过的数据都不能很好的预测。\n",
    "- For very high model complexity (a high-variance model), the training data is over-fit, which means that the model predicts the training data very well, but fails for any previously unseen data.  对于非常高的模型复杂度（高方差模型），训练数据过于拟合，这意味着模型很好地预测了训练数据，但是对于之前没遇到过的数据来说预测效果是很差的。\n",
    "\n",
    "- For some intermediate value, the validation curve has a maximum. This level of complexity indicates a suitable trade-off between bias and variance.  对于某些中间值，验证曲线是最大的。这种复杂性表明了偏差和方差之间的适当权衡。\n",
    "\n",
    "The means of tuning the model complexity varies from model to model; when we discuss individual models in depth in later sections, we will see how each model allows for such tuning. 对模型复杂性进行调优的方法因模型而异;当我们在后面的小节中深入讨论单个模型时，我们将看到每个模型如何进行这样的调优。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Validation curves in Scikit-Learn  Scikit-Learn 的 验证曲线\n",
    "\n",
    "Let's look at an example of using cross-validation to compute the validation curve for a class of models.\n",
    "Here we will use a *polynomial regression* model: this is a generalized linear model in which the degree of the polynomial is a tunable parameter.\n",
    "For example, a degree-1 polynomial fits a straight line to the data; for model parameters $a$ and $b$:\n",
    "\n",
    "\n",
    "让我们看一个使用交叉验证来计算类模型的验证曲线的例子。这里我们将使用一个多项式回归模型：这是一个广义线性模型，其中多项式的程度是一个可调参数。例如，多项式次数为 1，其实就是将数据的拟合成一条直线;模型参数  $a$ 和 $b$：\n",
    "\n",
    "$$\n",
    "y = ax + b\n",
    "$$\n",
    "\n",
    "A degree-3 polynomial fits a cubic curve to the data; for model parameters $a, b, c, d$:\n",
    "\n",
    "多项式次数为3，就是将数据拟合成一条3次曲线; 模型参数 $a, b, c, d$:\n",
    "\n",
    "$$\n",
    "y = ax^3 + bx^2 + cx + d\n",
    "$$\n",
    "\n",
    "We can generalize this to any number of polynomial features.\n",
    "In Scikit-Learn, we can implement this with a simple linear regression combined with the polynomial preprocessor.\n",
    "We will use a *pipeline* to string these operations together (we will discuss polynomial features and pipelines more fully in [Feature Engineering](05.04-Feature-Engineering.ipynb)):\n",
    "\n",
    "\n",
    "我们可以任意次数的多项式。在Scikit-Learn中，我们可以用一个带有多项式预处理器简单的线性回归实现。我们将使用一条管道将这些操作串在一起（我们将在特性工程中更全面地讨论多项式特性和管道）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.pipeline import make_pipeline\n",
    "\n",
    "# degree 多项式 次数\n",
    "def PolynomialRegression(degree=2, **kwargs):\n",
    "    return make_pipeline(PolynomialFeatures(degree),\n",
    "                         LinearRegression(**kwargs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Now let's create some data to which we will fit our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def make_data(N, err=1.0, rseed=1):\n",
    "    # randomly sample the data\n",
    "    rng = np.random.RandomState(rseed)\n",
    "    X = rng.rand(N, 1) ** 2\n",
    "    y = 10 - 1. / (X.ravel() + 0.1)\n",
    "    if err > 0:\n",
    "        y += err * rng.randn(N)\n",
    "    return X, y\n",
    "\n",
    "X, y = make_data(40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now visualize our data, along with polynomial fits of several degrees:\n",
    "\n",
    "我们现在可以看到我们的数据，以及几个不同的多项式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set()  # plot formatting\n",
    "\n",
    "X_test = np.linspace(-0.1, 1.1, 500)[:, None]\n",
    "\n",
    "plt.scatter(X.ravel(), y, color='black')\n",
    "axis = plt.axis()\n",
    "for degree in [1, 3, 5]:\n",
    "    y_test = PolynomialRegression(degree).fit(X, y).predict(X_test)\n",
    "    plt.plot(X_test.ravel(), y_test, label='degree={0}'.format(degree))\n",
    "plt.xlim(-0.1, 1.0)\n",
    "plt.ylim(-2, 12)\n",
    "plt.legend(loc='best');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The knob controlling model complexity in this case is the degree of the polynomial, which can be any non-negative integer.\n",
    "A useful question to answer is this: what degree of polynomial provides a suitable trade-off between bias (under-fitting) and variance (over-fitting)?\n",
    "\n",
    "在这种情况下，控制模型复杂度的是多项式的次数，它可以是任何非负整数。一个有用的问题是：多项式次数究竟是多少才能在偏差（不适当）和方差（过度拟合）之间提供权衡？\n",
    "\n",
    "We can make progress in this by visualizing the validation curve for this particular data and model; this can be done straightforwardly using the ``validation_curve`` convenience routine provided by Scikit-Learn.\n",
    "Given a model, data, parameter name, and a range to explore, this function will automatically compute both the training score and validation score across the range:\n",
    "\n",
    "我们可以通过可视化这个特定数据和模型的验证曲线来取得进展;这可以直接使用由Scikit-Learn提供的``validation_curve``便利程序来完成。给定一个模型、数据、参数名和一个可探索的范围，这个函数将自动计算训练分数和验证分数的所在范围："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.learning_curve import validation_curve\n",
    "degree = np.arange(0, 21)\n",
    "train_score, val_score = validation_curve(PolynomialRegression(), X, y,\n",
    "                                          'polynomialfeatures__degree', degree, cv=7)\n",
    "\n",
    "plt.plot(degree, np.median(train_score, 1), color='blue', label='training score')\n",
    "plt.plot(degree, np.median(val_score, 1), color='red', label='validation score')\n",
    "plt.legend(loc='best')\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel('degree')\n",
    "plt.ylabel('score');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows precisely the qualitative behavior we expect: the training score is everywhere higher than the validation score; the training score is monotonically improving with increased model complexity; and the validation score reaches a maximum before dropping off as the model becomes over-fit.\n",
    "\n",
    "这恰恰显示了我们所期望的定性行为：训练分数比验证分数高;训练分数随着模型复杂度的增加而单调地提高;当模型变得过于合适时，验证分数会达到最大值。\n",
    "\n",
    "From the validation curve, we can read-off that the optimal trade-off between bias and variance is found for a third-order polynomial; we can compute and display this fit over the original data as follows:\n",
    "\n",
    "从验证曲线中，我们可以看出，在三阶多项式中，存在偏差和方差之间的最佳权衡;我们可以根据原始数据来计算和显示这个匹配："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeYAAAFVCAYAAAA6zUwUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10d3ecdd8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X.ravel(), y)\n",
    "lim = plt.axis()\n",
    "y_test = PolynomialRegression(3).fit(X, y).predict(X_test)\n",
    "plt.plot(X_test.ravel(), y_test);\n",
    "plt.axis(lim);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that finding this optimal model did not actually require us to compute the training score, but examining the relationship between the training score and validation score can give us useful insight into the performance of the model.\n",
    "\n",
    "请注意，找到这个最优模型实际上并不要求我们计算训练分数，但是检查训练分数和验证分数之间的关系可以让我们对模型的性能有很好的了解。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Curves\n",
    "\n",
    "One important aspect of model complexity is that the optimal model will generally depend on the size of your training data.\n",
    "For example, let's generate a new dataset with a factor of five more points:\n",
    "\n",
    "\n",
    "模型复杂性的一个重要方面是，最优模型通常取决于您的训练数据集的大小。例如，让我们生成一个新的数据集，再增加5倍的点："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeYAAAFVCAYAAAA6zUwUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11944a278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X2, y2 = make_data(200)\n",
    "plt.scatter(X2.ravel(), y2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will duplicate the preceding code to plot the validation curve for this larger dataset; for reference let's over-plot the previous results as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfYAAAFkCAYAAADSRRn0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x119451f98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "degree = np.arange(21)\n",
    "train_score2, val_score2 = validation_curve(PolynomialRegression(), X2, y2,\n",
    "                                            'polynomialfeatures__degree', degree, cv=7)\n",
    "\n",
    "plt.plot(degree, np.median(train_score2, 1), color='blue', label='training score')\n",
    "plt.plot(degree, np.median(val_score2, 1), color='red', label='validation score')\n",
    "plt.plot(degree, np.median(train_score, 1), color='blue', alpha=0.3, linestyle='dashed')\n",
    "plt.plot(degree, np.median(val_score, 1), color='red', alpha=0.3, linestyle='dashed')\n",
    "plt.legend(loc='lower center')\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel('degree')\n",
    "plt.ylabel('score');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solid lines show the new results, while the fainter dashed lines show the results of the previous smaller dataset.\n",
    "It is clear from the validation curve that the larger dataset can support a much more complicated model: the peak here is probably around a degree of 6, but even a degree-20 model is not seriously over-fitting the data—the validation and training scores remain very close.\n",
    "\n",
    "实线显示了新的结果，而较弱的虚线显示了先前较小数据集的结果。从验证曲线中可以清楚地看出，较大的数据集可以支持一个更加复杂的模型：这里的顶点可能在6次多项式，但即使是一个20次多项式的模型也没有严重地过度拟合数据——验证和训练分数仍然非常接近。\n",
    "\n",
    "Thus we see that the behavior of the validation curve has not one but two important inputs: the model complexity and the number of training points.\n",
    "It is often useful to to explore the behavior of the model as a function of the number of training points, which we can do by using increasingly larger subsets of the data to fit our model.\n",
    "A plot of the training/validation score with respect to the size of the training set is known as a *learning curve.*\n",
    "\n",
    "因此，我们看到验证曲线的行为不是一个而是两个重要的输入：模型的复杂性和训练点的数量。将模型看作为与训练数据的规模相关的函数，以此来观察模型的行为。反应训练集规模的训练分数/验证分数被称为``学习曲线``。\n",
    "\n",
    "The general behavior we would expect from a learning curve is this:\n",
    "\n",
    "我们从学习曲线中得到的一般行为是这样的：\n",
    "\n",
    "- A model of a given complexity will *overfit* a small dataset: this means the training score will be relatively high, while the validation score will be relatively low. 一个给定的复杂性的模型相对于一个小的数据集容易过拟合：这意味着训练分数将相对较高，而验证分数将相对较低。\n",
    "- A model of a given complexity will *underfit* a large dataset: this means that the training score will decrease, but the validation score will increase.  一个给定复杂度的模型相对于一个大数据集容易欠拟合：这意味着训练分数将会降低，但是验证分数将会增加。\n",
    "- A model will never, except by chance, give a better score to the validation set than the training set: this means the curves should keep getting closer together but never cross.  一个模型不会在验证集上比训练集给出一个更好的分数：这意味着曲线应该保持在更近的距离，但永远不会相交。\n",
    "\n",
    "With these features in mind, we would expect a learning curve to look qualitatively like that shown in the following figure:\n",
    "\n",
    "考虑到这些特性，我们期望学习曲线从质量上看如下图所示："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/05.03-learning-curve.png)\n",
    "[figure source in Appendix](06.00-Figure-Code.ipynb#Learning-Curve)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The notable feature of the learning curve is the convergence to a particular score as the number of training samples grows.\n",
    "In particular, once you have enough points that a particular model has converged, *adding more training data will not help you!*\n",
    "The only way to increase model performance in this case is to use another (often more complex) model.\n",
    "\n",
    "学习曲线的显著特征是随着训练样本数量的增加，它与一个特定的分数趋于一致。特别地，一旦你有了足够多的点，一个特定的模型已经聚合，添加更多的训练数据将不会对你有帮助！在这种情况下，提高模型性能的惟一方法是使用另一个（通常更复杂的）模型。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning curves in Scikit-Learn\n",
    "\n",
    "Scikit-Learn offers a convenient utility for computing such learning curves from your models; here we will compute a learning curve for our original dataset with a second-order polynomial model and a ninth-order polynomial:\n",
    "\n",
    "Scikit-Learn提供了一种方便的实用工具，可以从你的模型中计算出这样的学习曲线;在这里，我们将用二阶多项式模型和九阶多项式来计算原始数据集的学习曲线："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.learning_curve import learning_curve\n",
    "\n",
    "fig, ax = plt.subplots(1, 2, figsize=(16, 6))\n",
    "fig.subplots_adjust(left=0.0625, right=0.95, wspace=0.1)\n",
    "\n",
    "for i, degree in enumerate([2, 9]):\n",
    "    N, train_lc, val_lc = learning_curve(PolynomialRegression(degree),\n",
    "                                         X, y, cv=7,\n",
    "                                         train_sizes=np.linspace(0.3, 1, 25))\n",
    "\n",
    "    ax[i].plot(N, np.mean(train_lc, 1), color='blue', label='training score')\n",
    "    ax[i].plot(N, np.mean(val_lc, 1), color='red', label='validation score')\n",
    "    ax[i].hlines(np.mean([train_lc[-1], val_lc[-1]]), N[0], N[-1],\n",
    "                 color='gray', linestyle='dashed')\n",
    "\n",
    "    ax[i].set_ylim(0, 1)\n",
    "    ax[i].set_xlim(N[0], N[-1])\n",
    "    ax[i].set_xlabel('training size')\n",
    "    ax[i].set_ylabel('score')\n",
    "    ax[i].set_title('degree = {0}'.format(degree), size=14)\n",
    "    ax[i].legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a valuable diagnostic, because it gives us a visual depiction of how our model responds to increasing training data.\n",
    "In particular, when your learning curve has already converged (i.e., when the training and validation curves are already close to each other) *adding more training data will not significantly improve the fit!*\n",
    "This situation is seen in the left panel, with the learning curve for the degree-2 model.\n",
    "\n",
    "这是一个有价值的诊断，因为它给我们提供了一个可视化的描述，说明我们的模型是如何对不断增加的训练数据做出反应的。特别是当你的学习曲线已经收敛的时候（例如当训练和验证曲线已经接近彼此的时候）增加更多的训练数据将不会显著地提高适应性！这种情况在左边的面板中可以看到2次项式模型的学习曲线。\n",
    "\n",
    "The only way to increase the converged score is to use a different (usually more complicated) model.\n",
    "We see this in the right panel: by moving to a much more complicated model, we increase the score of convergence (indicated by the dashed line), but at the expense of higher model variance (indicated by the difference between the training and validation scores).\n",
    "If we were to add even more data points, the learning curve for the more complicated model would eventually converge.\n",
    "\n",
    "提高收敛分数的唯一方法是使用一个不同的（通常更复杂的）模型。我们在右边的面板中看到了这一点：采用一个更复杂度的模型之后，我们增加了收敛的分数（由虚线表示），但是代价是更高的模型方差（由训练和验证分数之间的差异来表示）。如果我们要添加更多的数据点，更复杂的模型的学习曲线最终会收敛。\n",
    "\n",
    "Plotting a learning curve for your particular choice of model and dataset can help you to make this type of decision about how to move forward in improving your analysis.\n",
    "\n",
    "您选择的模型和数据集绘制一条学习曲线，可以帮助您找到改进的正确方向，不断改进学习效果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validation in Practice: Grid Search 实践验证：网格搜索\n",
    "\n",
    "The preceding discussion is meant to give you some intuition into the trade-off between bias and variance, and its dependence on model complexity and training set size.\n",
    "In practice, models generally have more than one knob to turn, and thus plots of validation and learning curves change from lines to multi-dimensional surfaces.\n",
    "In these cases, such visualizations are difficult and we would rather simply find the particular model that maximizes the validation score.\n",
    "\n",
    "前面的讨论是为了让您对偏差和方差之间的权衡有一些直观认识，以及它对模型复杂性和训练集大小的依赖。在实践中，模型通常有不止一个得分转折点，因此验证和学习曲线会从二维多维到多维的曲面。在这些情况下，这样的可视化是很困难的，我们宁愿简单地找到最大化验证分数的特定模型。\n",
    "\n",
    "Scikit-Learn provides automated tools to do this in the grid search module.\n",
    "Here is an example of using grid search to find the optimal polynomial model.\n",
    "We will explore a three-dimensional grid of model features; namely the polynomial degree, the flag telling us whether to fit the intercept, and the flag telling us whether to normalize the problem.\n",
    "This can be set up using Scikit-Learn's ``GridSearchCV`` meta-estimator:\n",
    "\n",
    "Scikit-Learn提供了在网格搜索模块中实现这一功能的自动化工具。这里有一个使用网格搜索来找到最优多项式模型的例子。我们将在一个三维的模型特征网格中寻找最优值，也就是多项式的次数的搜索范围，回归模型是否拟合截距，以及回归模型是否需要进行标准化处理。这可以使用Scikit-Learn的GridSearchCV元估计器来设置："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.grid_search import GridSearchCV\n",
    "\n",
    "param_grid = {'polynomialfeatures__degree': np.arange(21),\n",
    "              'linearregression__fit_intercept': [True, False],\n",
    "              'linearregression__normalize': [True, False]}\n",
    "\n",
    "grid = GridSearchCV(PolynomialRegression(), param_grid, cv=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that like a normal estimator, this has not yet been applied to any data.\n",
    "Calling the ``fit()`` method will fit the model at each grid point, keeping track of the scores along the way:\n",
    "\n",
    "注意，就像普通的估计量一样，这还没有应用到任何数据上。调用fit（）方法将在每个网格点上拟合模型，并同时记录每个点的分数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid.fit(X, y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that this is fit, we can ask for the best parameters as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'linearregression__fit_intercept': False,\n",
       " 'linearregression__normalize': True,\n",
       " 'polynomialfeatures__degree': 4}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, if we wish, we can use the best model and show the fit to our data using code from before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\matplotlib\\pyplot.py:3356: MatplotlibDeprecationWarning: The 'hold' keyword argument is deprecated since 2.0.\n",
      "  mplDeprecation)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = grid.best_estimator_\n",
    "\n",
    "plt.scatter(X.ravel(), y)\n",
    "lim = plt.axis()\n",
    "y_test = model.fit(X, y).predict(X_test)\n",
    "plt.plot(X_test.ravel(), y_test, hold=True);\n",
    "plt.axis(lim);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The grid search provides many more options, including the ability to specify a custom scoring function, to parallelize the computations, to do randomized searches, and more.\n",
    "For information, see the examples in [In-Depth: Kernel Density Estimation](05.13-Kernel-Density-Estimation.ipynb) and [Feature Engineering: Working with Images](05.14-Image-Features.ipynb), or refer to Scikit-Learn's [grid search documentation](http://Scikit-Learn.org/stable/modules/grid_search.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "In this section, we have begun to explore the concept of model validation and hyperparameter optimization, focusing on intuitive aspects of the bias–variance trade-off and how it comes into play when fitting models to data.\n",
    "In particular, we found that the use of a validation set or cross-validation approach is *vital* when tuning parameters in order to avoid over-fitting for more complex/flexible models.\n",
    "\n",
    "In later sections, we will discuss the details of particularly useful models, and throughout will talk about what tuning is available for these models and how these free parameters affect model complexity.\n",
    "Keep the lessons of this section in mind as you read on and learn about these machine learning approaches!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [Introducing Scikit-Learn](05.02-Introducing-Scikit-Learn.ipynb) | [Contents](Index.ipynb) | [Feature Engineering](05.04-Feature-Engineering.ipynb) >"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
